home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / (A)Z / (A)Z11.ADF / LOGO / LOGOSOURCE / turtle.c < prev    next >
C/C++ Source or Header  |  1987-06-29  |  10KB  |  618 lines
  1.  
  2. #include "logo.h"
  3.  
  4. #ifndef NOTURTLE
  5.  
  6. #include <math.h>
  7.  
  8. extern char *getenv();
  9. int turtdes; /* file descriptor for open turtle */
  10. int color;    /* pen color */
  11. int pendown = 0; /* nonzero with pen down */
  12. int penerase = 0; /* 0=pd, 1=pe, 2=px, pendown must be nonzero */
  13. int shown = 1;    /* nonzero if turtle is visible */
  14. int textmode = 0;    /* not turtle off */
  15. NUMBER yscrunch;    /* scale factor for y */
  16. struct display *mydpy;
  17.  
  18. #ifdef AMIGA
  19. #include "amiga.i"
  20. #endif
  21.  
  22. #ifdef ATARI
  23. #include "atari.i"
  24. #endif
  25.  
  26. #ifdef GIGI
  27. #include "gigi.i"
  28. #endif
  29.  
  30. #ifdef ADM
  31. #include "admtek.i"
  32. #include "adm.i"
  33. #endif
  34.  
  35. #ifdef TEK
  36. #ifndef ADM
  37. #include "admtek.i"
  38. #endif
  39. #include "tek.i"
  40. #endif
  41.  
  42. #ifdef SUN
  43. #include "sun.i"
  44. #endif
  45.  
  46. NUMBER ncheck(arg)
  47. struct object *arg;
  48. {
  49.     NUMBER val;
  50.  
  51.     arg = numconv(arg,"Turtle command");
  52.     arg = dubconv(arg);
  53.     val = arg->obdub;
  54.     mfree(arg);
  55.     return(val);
  56. }
  57.  
  58. dpyinit() {
  59.     char *ttytype;
  60.  
  61.     ttytype = getenv("TERM");
  62. #ifdef AMIGA
  63.     if (1)
  64.         mydpy = &amiga;
  65.     else
  66. #endif
  67. #ifdef GIGI
  68.     if (!strcmp(ttytype,"gigi"))
  69.         mydpy = &gigi;
  70.     else
  71. #endif
  72. #ifdef ATARI
  73.     if (!strcmp(ttytype,"atari"))
  74.         mydpy = &bwatari;
  75.     else
  76. #endif
  77. #ifdef ADM
  78.     if (!strncmp(ttytype,"adm",3))
  79.         mydpy = &adm;
  80.     else
  81. #endif
  82. #ifdef TEK
  83.     if (!strncmp(ttytype,"tek",3))
  84.         mydpy = &tek;
  85.     else
  86. #endif
  87. #ifdef SUN
  88.     if (1 || !strcmp(ttytype,"sun"))    /* Sun is always a sun */
  89.         mydpy = &sun;
  90.     else
  91. #endif
  92.     {
  93.         printf("I don't recognize your terminal type!\n");
  94.         errhand();
  95.     }
  96.     pendown = 1; penerase = 0; shown = 1;
  97.     textmode = 0;
  98.     mydpy->turtx = mydpy->turty = mydpy->turth = 0.0;
  99.     printf(mydpy->init);
  100.     if (!(mydpy->cleared)) {
  101.         printf(mydpy->clear);
  102.         (*mydpy->state)('c');
  103.         mydpy->cleared++;
  104.         yscrunch = mydpy->stdscrunch;
  105.     }
  106.     turtdes = -1;
  107.     (*mydpy->infn)();
  108.     (*mydpy->drawturt)(0);
  109. }
  110.  
  111. struct object *getturtle(arg)
  112. register struct object *arg;
  113. {
  114.     int lsflag[2];    /* BH 1/4/81 */
  115.     register char *temp,*argc;
  116.     char c[100];
  117.     char astr[20];
  118.  
  119.     if (stringp(arg)) argc = arg->obstr;
  120.     else argc = "";
  121.     if (!strcmp(argc,"off")) {
  122. #ifdef FLOOR
  123.         if (turtdes>0) {
  124.             close (turtdes);
  125.             printf("Please\007 unplug the turtle\007 and put it\007 away!\n");
  126.         }
  127. #endif /* FLOOR */
  128.         if (turtdes<0) {
  129.             printf(mydpy->finish);
  130.             (*mydpy->outfn)();
  131.         }
  132.         turtdes = 0;
  133.         mfree(arg);
  134.         return((struct object *)(-1));
  135.     }
  136.     if (!strcmp(argc,"dpy")||!strcmp(argc,"display")) {
  137.  
  138. #ifdef FLOOR
  139.         if (turtdes>0) {
  140.             close (turtdes);
  141.             printf("Please\007 unplug the turtle\007 and put it\007 away!\n");
  142.         }
  143. #endif /* FLOOR */
  144.  
  145.         dpyinit();
  146.         mfree(arg);
  147.         return ((struct object *)(-1));
  148.     }
  149. #ifdef FLOOR
  150.     if (intp(arg)) {
  151.         sprintf(astr,FIXFMT,arg->obint);
  152.         argc = astr;
  153.     }
  154.     temp = c;
  155.     cpystr(temp,"/dev/turtle",argc,NULL);
  156.     if (turtdes>0) close(turtdes);
  157.     if((turtdes = open(c,2)) < 0) {
  158.         turtdes = 0;
  159.         pf1("Turtle %l not available.\n",arg);
  160.     } else printf("Please put the turtle away when you're done!\n");
  161.     mfree(arg);
  162.     return ((struct object *)(-1));
  163. #else
  164.     ungood("Turtle",arg);
  165. #endif /* FLOOR */
  166. }
  167.  
  168. dpysxy(newx,newy)
  169. NUMBER newx,newy;
  170. {
  171.     if ((newx < mydpy->xlow) || (newx > mydpy->xhigh) ||
  172.         (newy < mydpy->ylow) || (newy > mydpy->yhigh)) {
  173.             puts("Out of bounds!");
  174.             errhand();
  175.     }
  176.     if (shown) (*mydpy->drawturt)(1);
  177.     if (fabs(newx) < 0.01) newx = 0.0;
  178.     if (fabs(newy) < 0.01) newy = 0.0;
  179.     if (pendown)
  180.         (*mydpy->drawfrom)(mydpy->turtx,yscrunch*mydpy->turty);
  181.     mydpy->turtx = newx;
  182.     mydpy->turty = newy;
  183.     if (pendown)
  184.         (*mydpy->drawto)(newx,yscrunch*newy);
  185.     (*mydpy->state)('G');
  186.     if (shown) (*mydpy->drawturt)(0);
  187. }
  188.  
  189. dpyforw(dist)
  190. NUMBER dist;
  191. {
  192.     NUMBER newx,newy,deltax,deltay;
  193.  
  194.     tcheck();
  195.     (*mydpy->txtchk)();
  196.     deltax = dist * sin((mydpy->turth)*3.141592654/180.0);
  197.     if (fabs(deltax) < 1.0e-5) deltax = 0.0;
  198.     deltay = dist * cos((mydpy->turth)*3.141592654/180.0);
  199.     if (fabs(deltay) < 1.0e-5) deltay = 0.0;
  200.     newx = mydpy->turtx + deltax;
  201.     newy = mydpy->turty + deltay;
  202.     dpysxy(newx,newy);
  203. }
  204.  
  205. struct object *forward(arg)
  206. register struct object *arg;
  207. {
  208.     NUMBER dist;
  209.  
  210.     dist = ncheck(arg);
  211. #ifdef FLOOR
  212.     if (turtdes > 0) {
  213.         if (dist < 0.0)
  214.             moveturtle('b',-6*(int)dist);
  215.         else
  216.             moveturtle('f',6*(int)dist);
  217.         return ((struct object *)(-1));
  218.     }
  219. #endif /* FLOOR */
  220.     dpyforw(dist);
  221.     return ((struct object *)(-1));
  222. }
  223.  
  224. struct object *back(arg)
  225. register struct object *arg;
  226. {
  227.     NUMBER dist;
  228.  
  229.     dist = ncheck(arg);
  230. #ifdef FLOOR
  231.     if (turtdes > 0) {
  232.         if (dist < 0.0)
  233.             moveturtle('f',-6*(int)dist);
  234.         else
  235.             moveturtle('b',6*(int)dist);
  236.         return ((struct object *)(-1));
  237.     }
  238. #endif /* FLOOR */
  239.     dpyforw(-dist);
  240.     return ((struct object *)(-1));
  241. }
  242.  
  243. dpysh(angle)
  244. NUMBER angle;
  245. {
  246.     (*mydpy->txtchk)();
  247.     if (shown) (*mydpy->drawturt)(1);
  248.     mydpy->turth = angle;
  249.     while (mydpy->turth+11.0 < 0.0) mydpy->turth += 360.0;
  250.     while (mydpy->turth+11.0 >= 360.0) mydpy->turth -= 360.0;
  251.     if (shown) (*mydpy->drawturt)(0);
  252.     (*mydpy->turnturt)();
  253. }
  254.  
  255. dpyturn(angle)
  256. NUMBER angle;
  257. {
  258.     tcheck();
  259.     dpysh(mydpy->turth + angle);
  260. }
  261.  
  262. struct object *left(arg)
  263. register struct object *arg;
  264. {
  265.     NUMBER dist;
  266.  
  267.     dist = ncheck(arg);
  268. #ifdef FLOOR
  269.     if (turtdes > 0) {
  270.         if (dist < 0.0)
  271.             moveturtle('r',(-2*(int)dist)/5);
  272.         else
  273.             moveturtle('l',(2*(int)dist)/5);
  274.         return ((struct object *)(-1));
  275.     }
  276. #endif /* FLOOR */
  277.     dpyturn(-dist);
  278.     return ((struct object *)(-1));
  279. }
  280.  
  281. struct object *right(arg)
  282. register struct object *arg;
  283. {
  284.     NUMBER dist;
  285.  
  286.     dist = ncheck(arg);
  287. #ifdef FLOOR
  288.     if (turtdes > 0) {
  289.         if (dist < 0.0)
  290.             moveturtle('l',(-2*(int)dist)/5);
  291.         else
  292.             moveturtle('r',(2*(int)dist)/5);
  293.         return ((struct object *)(-1));
  294.     }
  295. #endif /* FLOOR */
  296.     dpyturn(dist);
  297.     return ((struct object *)(-1));
  298. }
  299.  
  300. #ifdef FLOOR
  301. fcheck() {
  302.     if (turtdes <= 0) {
  303.         puts("You don't have a floor turtle!");
  304.         errhand();
  305.     }
  306. }
  307.  
  308. struct object *hitoot(arg)
  309. register struct object *arg;
  310. {
  311.     NUMBER dist;
  312.  
  313.     fcheck();
  314.     dist = ncheck(arg);
  315.     moveturtle('H',(15*(int)dist)/2);
  316.     return ((struct object *)(-1));
  317. }
  318.  
  319. struct object *lotoot(arg)
  320. register struct object *arg;
  321. {
  322.     NUMBER dist;
  323.  
  324.     fcheck();
  325.     dist = ncheck(arg);
  326.     moveturtle('L',(15*(int)dist)/2);
  327.     return ((struct object *)(-1));
  328. }
  329.  
  330. moveturtle(where,arg)
  331. register int arg;
  332. {
  333.     char buff[2];
  334.  
  335.     buff[0] = where;
  336.     while (arg >= 0400) {
  337.         buff[1] = 0377;
  338.         write(turtdes,buff,2);
  339.         arg -= 0377;
  340.     }
  341.     buff[1] = arg;
  342.     write(turtdes,buff,2);
  343. }
  344.  
  345. lampon() {
  346.     int i;
  347.  
  348.     fcheck();
  349.     i = 'B';
  350.     write(turtdes,&i,2);
  351. }
  352.  
  353. lampoff() {
  354.     int i;
  355.  
  356.     fcheck();
  357.     i = 'B'+0400;
  358.     write(turtdes,&i,2);
  359. }
  360.  
  361. struct object *touchsense(which)
  362. {
  363.     char x;
  364.  
  365.     fcheck();
  366.     read (turtdes,&x,1);
  367.     if ( (0200>>which) & x) return (true());
  368.     else return (false());
  369. }
  370.  
  371. struct object *ftouch() {
  372.     return(touchsense(0));
  373. }
  374.  
  375. struct object *btouch() {
  376.     return(touchsense(1));
  377. }
  378.  
  379. struct object *ltouch() {
  380.     return(touchsense(2));
  381. }
  382.  
  383. struct object *rtouch() {
  384.     return(touchsense(3));
  385. }
  386. #endif
  387.  
  388. int tcheck() {
  389.     if (turtdes > 0) {
  390.         puts("You don't have a display turtle!");
  391.         errhand();
  392.     }
  393.     if (turtdes == 0) dpyinit();    /* free turtle "display */
  394. }
  395.  
  396. NUMBER posangle(angle)
  397. NUMBER angle;
  398. {
  399.     if (angle < 0.0) return(angle+360.0);
  400.     return(angle);
  401. }
  402.  
  403. struct object *pencolor(pen)
  404. struct object *pen;
  405. {
  406.     NUMBER dpen;
  407.  
  408.     tcheck();
  409.     (*mydpy->txtchk)();
  410.     dpen = ncheck(pen);
  411.     (*mydpy->penc)((int)dpen);
  412.     color = dpen;
  413.     return ((struct object *)(-1));
  414. }
  415.  
  416. int setcolor(pen,colorlist)
  417. struct object *pen,*colorlist;
  418. {
  419.     NUMBER number;
  420.     register int ipen;
  421.  
  422.     tcheck();
  423.     (*mydpy->txtchk)();
  424.     number = ncheck(pen);
  425.     ipen = number;
  426.     (*mydpy->setc)(ipen,colorlist);
  427. }
  428.  
  429. int setxy(strx,stry)
  430. struct object *strx,*stry;
  431. {
  432.     NUMBER x,y;
  433.  
  434.     tcheck();
  435.     (*mydpy->txtchk)();
  436.     x = ncheck(strx);
  437.     y = ncheck(stry);
  438.     dpysxy(x,y);
  439. }
  440.  
  441. struct object *setheading(arg)
  442. struct object *arg;
  443. {
  444.     NUMBER heading;
  445.  
  446.     tcheck();
  447.     (*mydpy->txtchk)();
  448.     heading = ncheck(arg);
  449.     dpysh(heading);
  450.     return ((struct object *)(-1));
  451. }
  452.  
  453. struct object *xcor()
  454. {
  455.     tcheck();
  456.     return(localize(objdub(mydpy->turtx)));
  457. }
  458.  
  459. struct object *ycor()
  460. {
  461.     tcheck();
  462.     return(localize(objdub(mydpy->turty)));
  463. }
  464.  
  465. struct object *heading()
  466. {
  467.     tcheck();
  468.     return(localize(objdub(posangle(mydpy->turth))));
  469. }
  470.  
  471. struct object *getpen()
  472. {
  473.     tcheck();
  474.     return(localize(objint(color)));
  475. }
  476.  
  477. struct object *setscrunch(new)
  478. struct object *new;
  479. {
  480.     tcheck();
  481.     yscrunch = ncheck(new);
  482.     return ((struct object *)(-1));
  483. }
  484.  
  485. struct object *scrunch() {
  486.     tcheck();
  487.     return(localize(objdub(yscrunch)));
  488. }
  489.  
  490. penup() {
  491. #ifdef FLOOR
  492.     int i;
  493.  
  494.     if (turtdes>0) {
  495.         i = 'P'+0400;
  496.         write(turtdes,&i,2);
  497.         return;
  498.     }
  499. #endif FLOOR
  500.     tcheck();
  501.     pendown = 0;
  502.     (*mydpy->state)('U');
  503. }
  504.  
  505. cmpendown() {
  506. #ifdef FLOOR
  507.     int i;
  508.  
  509.     if (turtdes>0) {
  510.         i = 'P';
  511.         write(turtdes,&i,2);
  512.         return;
  513.     }
  514. #endif FLOOR
  515.     tcheck();
  516.     pendown = 1;
  517.     penerase = 0;
  518.     (*mydpy->state)('D');
  519. }
  520.  
  521. cmpenerase() {
  522.     tcheck();
  523.     pendown = penerase = 1;
  524.     (*mydpy->state)('E');
  525. }
  526.  
  527. penreverse() {
  528.     tcheck();
  529.     pendown = 1;
  530.     penerase = 2;
  531.     (*mydpy->state)('R');
  532. }
  533.  
  534. clearscreen() {
  535.     tcheck();
  536.     (*mydpy->txtchk)();
  537.     printf(mydpy->clear);
  538.     mydpy->turtx = mydpy->turty = mydpy->turth = 0.0;
  539.     (*mydpy->state)('c');
  540.     if (shown) (*mydpy->drawturt)(0);
  541. }
  542.  
  543. wipeclean() {
  544.     tcheck();
  545.     (*mydpy->txtchk)();
  546.     printf(mydpy->clear);
  547.     (*mydpy->state)('w');
  548.     if (shown) (*mydpy->drawturt)(0);
  549. }
  550.  
  551. fullscreen() {
  552.     tcheck();
  553.     (*mydpy->state)('f');
  554.     textmode = 0;
  555. }
  556.  
  557. splitscreen() {
  558.     tcheck();
  559.     (*mydpy->state)('s');
  560.     textmode = 0;
  561. }
  562.  
  563. textscreen() {
  564.     tcheck();
  565.     (*mydpy->state)('t');
  566.     textmode++;
  567. }
  568.  
  569. showturtle() {
  570.     tcheck();
  571.     (*mydpy->txtchk)();
  572.     if (!shown) (*mydpy->drawturt)(0);
  573.     shown = 1;
  574.     (*mydpy->state)('S');
  575. }
  576.  
  577. hideturtle() {
  578.     tcheck();
  579.     (*mydpy->txtchk)();
  580.     if (shown) (*mydpy->drawturt)(1);
  581.     shown = 0;
  582.     (*mydpy->state)('H');
  583. }
  584.  
  585. struct object *penmode() {
  586.     static char *pens[] = {"pendown","penerase","penreverse"};
  587.  
  588.     tcheck();
  589.     if (pendown) return(localize(objcpstr(pens[penerase])));
  590.     return(localize(objcpstr("penup")));
  591. }
  592.  
  593. struct object *shownp() {
  594.     tcheck();
  595.     return(torf(shown));
  596. }
  597.  
  598. struct object *towardsxy(x,y)
  599. struct object *x,*y;
  600. {
  601.     NUMBER dx,dy;
  602.  
  603.     tcheck();
  604.     dx = ncheck(x);
  605.     dy = ncheck(y);
  606. #ifndef AMIGA
  607.     return(localize(objdub(posangle((double)180.0*
  608.         atan2(dx-(mydpy->turtx),dy-(mydpy->turty))/3.141592654))));
  609. #else
  610.     return(localize(objdub(posangle((double)180.0*
  611.         atan(((dy-(mydpy->turty))/3.141592654) /
  612.              ((dy-(mydpy->turty))/3.141592654) )))));
  613. #endif
  614. }
  615.  
  616. #endif
  617.  
  618.